home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / SAT 2.4.0 & updates ƒ / SAT 2.4.0 ƒ / SAT Think Lib ƒ / SAT.p < prev    next >
Text File  |  1997-01-02  |  13KB  |  282 lines
  1. unit SAT;
  2.  
  3. interface
  4. {$ifc UNDEFINED THINK_PASCAL}
  5.     uses
  6.         Types, QuickDraw, Icons; {Icons assume UPI}
  7.  
  8. {$PUSH}
  9. {$ALIGN MAC68K}
  10. {$endc}
  11.  
  12.     type
  13.         SATPort = record
  14.                 port: GrafPtr;        {GrafPtr/WindowPtr, use for SetPort, ShowWindow…}
  15.                 device: GDHandle;    {Internal}
  16.                 rows: Ptr;            {Internal}
  17.                 bounds: Rect;            {Internal}
  18.                 baseAddr: Ptr;        {Internal}
  19.                 rowBytes: Integer;    {Internal}
  20.             end;
  21.         SATPortPtr = ^SATPort;
  22.  
  23.         FacePtr = ^Face;
  24.         Face = record
  25.                 colorData: Ptr;
  26.                 resNum: integer;
  27.                 iconMask: BitMap;
  28.                 rowBytes: integer;
  29.                 next: FacePtr;
  30.                 maskRgn: RgnHandle;
  31.                 rows, maskRows: Ptr;
  32.                 redrawProc: ProcPtr;    {Called on depth changes, not needed if loaded from a cicn}
  33.                 drawProc: ProcPtr;        {Called to draw the face (usually nil)}
  34.             end;
  35.  
  36.         SpritePtr = ^Sprite;
  37.         Sprite = record
  38. { Variables that you should change as appropriate }
  39.                 kind: Integer; { Used for identification. >0: friend. <0 foe }
  40.                 position: Point;
  41.                 hotRect, hotRect2: Rect; { Tells how large the sprite is; hotRect is centered around origo }
  42.                                     {hotRect is set by you. hotRect2 is offset to the current position.}
  43.                 face: FacePtr;            { Pointer to the Face (appearance) to be used. }
  44.                 task: ProcPtr;            { Callback-routine, called once per frame. If task=nil, the sprite is removed. }
  45.                 hitTask: ProcPtr;        { Callback in collisions. }
  46.                 destructTask: ProcPtr;    { Called when a sprite is disposed. (Usually nil.) }
  47.                 clip: RgnHandle;            {Clip region to be used when this sprite is drawn.}
  48. { SAT variables that you shouldn't change: }
  49.                 oldpos: Point;                {Used by RunSAT2}
  50.                 next, prev: SpritePtr;    {You may change them in your own sorting routine, but be careful if you do.}
  51.                 r, oldr: Rect;                {Rectangle telling where to draw. Avoid messing with it.}
  52.                 oldFace: FacePtr;            {Used by RunSAT2}
  53.                 dirty: Boolean;            {Used by RunSAT2}
  54. {Variables for internal use by the sprites. Use as you please. Edit as necessary - this is merely a default}
  55. {set, enough space for most cases - but if you change the size of the record, call SetSpriteSize immediately}
  56. {after initializing (before any sprites are created)!}
  57.                 layer: integer; {For layer-sorting. When not used for that, use freely.}
  58.                 speed: Point; { Can be used for speed, but not necessarily. }
  59.                 mode: integer; { Usually used for different modes and/or to determine what image to show next. }
  60.                 appPtr: Ptr; {Pointer for use by the application - i.e. pointer to extra data}
  61.                 appLong: Longint; {Longint for free use by the application.}
  62.             end;
  63.  
  64. {Type for SATs pattern utilities.}
  65.     type
  66.         SATPattern = record
  67.                 patternType: integer; {1 = Pattern, PatHandle, 2 = PixPat, PixPatHandle}
  68.                 thePat: PixPatHandle; {or PatHandle}
  69.             end; {record}
  70.         SATPatPtr = ^SATPattern;
  71.         SATPatHandle = ^SATPatPtr;
  72.  
  73. {Update list. Used internally}
  74.         UpdatePtr = ^UpdateRec;
  75.         UpdateRec = record
  76.                 updateRect: Rect;
  77.                 next: UpdatePtr;
  78.             end;
  79.  
  80. {The globals record. Some fields are important for you. These are marked with *}
  81.         SATglobalsRec = record
  82.                 wind: SATPort;                                {*The window that SAT draws in. You get the WindowPtr as gSAT.wind.port}
  83.                 offSizeH, offSizeV: integer;                    {*Offscreen size, used to limit sprite positions}
  84.                 offScreen: SATPort;                            {*Offscreen image }
  85.                 backScreen: SATPort;                        {*Background image }
  86.  
  87.                 ox, oy: longint;                                {Internal}
  88.                 pict, bwpict: integer;                        {PICT id's}
  89.                 fitThePICTs: boolean;                        {Resize PICTs to fit?}
  90.                 sorting: integer;                                {Chosen sorting}
  91.                 collision: integer;                            {Chosen collision handling}
  92.                 searchWidth: integer;                        {Chosen search width}
  93.                 screen: PixMapHandle;                        {Internal}
  94.                 bounds: Rect;                                    {Internal}
  95.                 initDepth: Integer;                            {*Depth at last icon initialization}
  96.                 synchHook: ProcPtr;                            {Synch procedure}
  97.                 sRoot: SpritePtr;                                {Sprite list root}
  98.                 updateRoot: UpdatePtr;                        {Update list root}
  99.                 anyMonsters: Boolean;                        {*False when no sprites with kind < -1 are active }
  100.  
  101.                 ditherOff: CGrafPtr;                            {Internal}
  102.                 ditherOffGD: GDHandle;                        {Internal}
  103.                 iconPort: SATPort;                            {Internal}
  104.                 iconPort2: SATPort;                            {Internal}
  105.                 bwIconPort: GrafPtr;                         {Internal}
  106. {Environment-independent globals:}
  107.                 faceRoot: FacePtr;                            {Root of face list}
  108.                 colorFlag: Boolean;                            {True if color QuickDraw is available.}
  109.                 mmuMode: SignedByte;                        {Addressing mode}
  110. {Blitters! You should not change these fields yourself. (Possibly for installing a blitter in your program code.)}
  111.                 rectBlit1, maskBlit1: ProcPtr;                {Supplied - this is either RBlt/MBlt 0 or 1}
  112.                 rectBlit2, maskBlit2: ProcPtr;                {Will probably never be used}
  113.                 rectBlit4, maskBlit4: ProcPtr;                {Supplied}
  114.                 rectBlit8, maskBlit8: ProcPtr;                {Supplied}
  115.                 rectBlit16, maskBlit16: ProcPtr;            {Not supplied}
  116.                 rectBlit32, maskBlit32: ProcPtr;            {Not supplied}
  117.                 curRectBlit, curMaskBlit: ProcPtr;            {Currently selected fast blitter}
  118.                 screenLocalDrawingArea: Rect;
  119.                 trashList: SpritePtr;
  120.             end;
  121.  
  122. {Configuration types: VPositionSort and KindCollision are defaults.}
  123.     const
  124. {Sorting options}
  125.         kVPositionSort = 0;
  126.         kLayerSort = 1;
  127.         kNoSort = 2;
  128. {Collision detection options}
  129.         kKindCollision = 0;
  130.         kForwardCollision = 1;
  131.         kBackwardCollision = 2;
  132.         kNoCollision = 3;
  133.         kForwardOneCollision = 4;
  134.         kBothCollision = 5;
  135.  
  136.     var
  137. {$ifc UNDEFINED THINK_PASCAL}
  138.         gSAT: SATglobalsRec;
  139.         external;                            {Most globals in a record. See above.}
  140.         gSATSoundErrorProc: ProcPtr;
  141.         external;                            {Pointer to procedure to call on sound error.}
  142. {$elsec}
  143. {$J+}
  144.         gSAT: SATglobalsRec;                {Most globals in a record. See above.}
  145.         gSATSoundErrorProc: ProcPtr;        {Pointer to procedure to call on sound error.}
  146. {$J-}
  147. {$endc}
  148.  
  149. {Initializing and customizing}
  150.     procedure SATConfigure (PICTfit: boolean; newSorting, newCollision, searchWidth: integer);
  151.     procedure SATInit (pictID, bwpictID, Xsize, Ysize: integer);
  152.     procedure SATCustomInit (pictID, bwpictID: integer; var SATdrawingArea: Rect; {}
  153.                                     preloadedWind: WindowPtr; chosenScreen: GDHandle; useMenuBar, {}
  154.                                     centerDrawingArea, fillScreen, dither4bit, beSmart: Boolean);
  155. {Maintainance, background manipulation etc.}
  156.     function SATDepthChangeTest: Boolean;
  157.     procedure SATDrawPICTs (pictID, bwpictID: integer);
  158.     procedure SATRedraw;
  159. {Drawing}
  160.     procedure SATPlotFace (theFace: FacePtr; theGrafPtr: SATPortPtr; where: Point; Fast: boolean);
  161.     procedure SATPlotFaceToScreen (theFace: FacePtr; where: Point; Fast: boolean);
  162. {SATCopybits is now only done with a CopyBits - so it's really obsolete.}
  163.     procedure SATCopyBits (src, dest: SATPortPtr; {}
  164.                                     var srcRect, destRect: Rect; fast: Boolean);
  165.     procedure SATCopyBitsToScreen (src: SATPortPtr; var srcRect, destRect: Rect; fast: Boolean);
  166.     procedure SATBackChanged (var r: Rect); {Tell SAT about changes in backScreen}
  167. {SetPort replacements}
  168.     procedure SATGetPort (var port: SATPort);
  169.     procedure SATSetPort (var port: SATPort);
  170.     procedure SATSetPortOffScreen; {Use before using QuickDraw on offScreen}
  171.     procedure SATSetPortBackScreen; {Use before using QuickDraw on backScreen}
  172.     procedure SATSetPortScreen; {Use to set port to gSAT.wind}
  173. {Basic sprite handling}
  174.     function SATGetFace (resNum: integer): FacePtr;
  175.     procedure SATDisposeFace (theFace: FacePtr);
  176.     function SATNewSprite (kind, hpos, vpos: integer; setup: ProcPtr): SpritePtr;
  177.     function SATNewSpriteAfter (afterthis: SpritePtr; kind, hpos, vpos: integer; setup: ProcPtr): SpritePtr;
  178.     procedure SATKillSprite (who: Spriteptr);
  179. {Animating}
  180.     procedure SATRun (fast: Boolean); {The heart of the whole package!}
  181.     procedure SATRun2 (fast: Boolean); {Alternate routine for allowing resting sprites}
  182. {Special functions for advanced programmers}
  183.     procedure SATInstallSynch (theSynchProc: ProcPtr);
  184.     procedure SATInstallEmergency (theEmergencyProc: ProcPtr);
  185.     procedure SATSetSpriteRecSize (theSize: longint);
  186.     procedure SATSkip;
  187.     procedure SATKill; {Dispose of offscreen buffers to allow re-init}
  188.     procedure SATWindMoved;
  189. {Offscreen - use only if you need an *extra* offscreen buffer. These calls are likely to change in the future!}
  190.     procedure SATMakeOffscreen (var portP: SATPort; var rectP: Rect); {Make offscreen buffer in current screen depth and CLUT.}
  191.     procedure SATDisposeOffScreen (var portP: SATPort); {Get rid of offscreen}
  192.     function CreateOffScreen (var bounds: Rect; depth: Integer; colors: CTabHandle; var retPort: CGrafPtr; var retGDevice: GDHandle): OSErr; {From Principia Offscreen - color only}
  193.     procedure DisposeOffScreen (doomedPort: CGrafPtr; doomedGDevice: GDHandle);{From Principia Offscreen - color only}
  194. {Face manipulation (for advanced programmers)}
  195.     procedure SATSetPortMask (theFace: FacePtr);
  196.     procedure SATSetPortFace (theFace: FacePtr);
  197.     procedure SATSetPortFace2 (theFace: FacePtr);
  198.     function SATNewFace (var faceBounds: Rect): FacePtr;
  199.     procedure SATChangedFace (theFace: FacePtr);
  200. {"Safe" blitter routines, using QuickDraw.}
  201.     procedure SATSafeRectBlit (var srcBits, destbits: SATPort; var r: rect);
  202.     procedure SATSafeMaskBlit (face: FacePtr; theSprite: SpritePtr; var destBits: SATPort; {}
  203.                                     srcPt, dstPt: Point; width, height: Integer);
  204.  
  205. {New procedures, EXPERIMENTAL, intended for making a C++ interface}
  206.     function SATGetFacePP (resNum: integer; fStorage: Ptr): FacePtr;
  207.     function SATNewSpritePP (afterthis: SpritePtr; sStorage: Ptr; theKind, hpos, vpos: integer; setup: ProcPtr): SpritePtr;
  208.     procedure SATCopySprite (destSprite: SpritePtr; srcSprite: SpritePtr);
  209.     function SATNewFacePP (var faceBounds: Rect; fStorage: Ptr): FacePtr;
  210.     procedure SATCopyFace (destFace: FacePtr; srcFace: FacePtr);
  211.     procedure SATDisposeFacePP (theFace: FacePtr);
  212.  
  213. {Cicn utilities}
  214.     function SATGetCicn (cicnId: integer): CIconHandle;
  215.     procedure SATPlotCicn (theCicn: CIconHandle; dest: GrafPtr; destGD: GDHandle; var r: Rect);
  216.     procedure SATDisposeCicn (theCicn: CIconHandle);
  217.  
  218. {Utilities}
  219.     procedure SATSetStrings (ok, yes, no, quit, memerr, noscreen, nopict, nowind: Str255);
  220.     function SATTrapAvailable (theTrap: Integer): Boolean;
  221.     procedure SATDrawInt (i: integer);
  222.     procedure SATDrawLong (l: longint);
  223.     function SATRand (n: integer): integer;
  224.     function SATRand10: integer;
  225.     function SATRand100: integer;
  226.     procedure SATReportStr (str: str255);
  227.     function SATQuestionStr (str: str255): Boolean;
  228.     function SATFakeAlert (s1, s2, s3, s4: Str255; nButtons, defButton, cancelButton: integer;{}
  229.                                     t1, t2, t3: Str255): integer;
  230.     procedure CheckNoMem (p: univ Ptr); {If the Ptr is nil, out of memory emergency exit}
  231.     procedure SATSetMouse (where: point);
  232.     procedure SATInitToolbox;
  233.     procedure SATGetVersion (var versionString: Str255);
  234. {Pattern utilities}
  235.     procedure SATPenPat (SATpat: SATPatHandle);
  236.     procedure SATBackPat (SATpat: SATPatHandle);
  237.     function SATGetPat (patID: integer): SATPatHandle;
  238.     procedure SATDisposePat (SATpat: SATPatHandle);
  239. {Menu bar utilities}
  240.     procedure SATShowMBar (wind: WindowPtr);
  241.     procedure SATHideMBar (wind: WindowPtr);
  242. {PICT utilities}
  243.     procedure SATGetandDrawPICTRes (id: integer);
  244.     procedure SATGetandDrawPICTResInRect (id: integer; var frame: Rect);
  245.     procedure SATGetandCenterPICTResInRect (id: integer; var frame: Rect);
  246. {Sound}
  247.     procedure SATSoundInit; {Called from SATInit}
  248.     procedure SATSoundPlay (theSound: Handle; priority: Integer; canWait: Boolean);
  249.     procedure SATSoundEvents; {Call this once in a while when not calling SATRun often}
  250.     procedure SATSoundShutup; {Silence, dispose of sound channel}
  251.     procedure SATSoundOn;
  252.     procedure SATSoundOff;
  253.     function SATSoundDone: Boolean; {Any sound going on ?}
  254.     function SATGetSound (sndId: Integer): Handle;        { To load a sound and get a handle for SATSoundPlay }
  255.     function SATGetNamedSound (name: Str255): Handle; { Same but using resource names }
  256.     procedure SATDisposeSound (theSnd: handle);
  257. {Multi-channel sound routines}
  258.     function SATSoundInitChannels (num: integer): integer;
  259.     function SATSoundDoneChannel (chanNum: integer): Boolean;
  260.     procedure SATSoundPlayChannel (theSound: Handle; chanNum: integer);
  261.     procedure SATSoundReserveChannel (chanNum: integer; reserve: Boolean);
  262.     procedure SATSoundShutupChannel (chanNum: integer);
  263.     procedure SATPreloadChannels;
  264. {Experimental, likely to be renamed/removed/changed:}
  265.     procedure SATSoundPlay2 (theSound: Handle; priority: integer; canWait, skipIfSame: Boolean);
  266.     procedure SATSoundPlayEasy (theSound: Handle; canWait: Boolean);
  267. {More multi-channel:}
  268.     function SATGetNumChannels: integer;
  269.     function SATGetChannel (chanNum: integer): Ptr;
  270. {Customization}
  271.     procedure SATSetSoundInitParams (params: Longint);
  272.  
  273. {Step-scrolling}
  274.     function SATStepScroll (viewPoint: Point; marginH, marginV, scrollSpeed: Integer): Boolean;
  275.  
  276. {$ifc UNDEFINED THINK_PASCAL}
  277. {$ALIGN RESET}
  278. {$POP}
  279. {$endc}
  280.  
  281. implementation
  282. end.